home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Games / MAME / src / cpu / m6800 / 6800ops.c < prev    next >
C/C++ Source or Header  |  2000-04-23  |  33KB  |  2,202 lines
  1.  
  2. /*
  3.  
  4. HNZVC
  5.  
  6. ? = undefined
  7. * = affected
  8. - = unaffected
  9. 0 = cleared
  10. 1 = set
  11. # = ccr directly affected by instruction
  12. @ = special - carry set if bit 7 is set
  13.  
  14. */
  15.  
  16. //INLINE void illegal( void )
  17. static void illegal( void )
  18. {
  19.     logerror("M6808: illegal opcode: address %04X, op %02X\n",PC,(int) M_RDOP_ARG(PC)&0xFF);
  20. }
  21.  
  22. /* HD63701 only */
  23. //INLINE void trap( void )
  24. static void trap( void )
  25. {
  26.     logerror("M6808: illegal opcode: address %04X, op %02X\n",PC,(int) M_RDOP_ARG(PC)&0xFF);
  27.     TAKE_TRAP;
  28. }
  29.  
  30. #if macintosh
  31. #pragma mark ____0x____
  32. #endif
  33.  
  34. /* $00 ILLEGAL */
  35.  
  36. /* $01 NOP */
  37. INLINE void nop( void )
  38. {
  39. }
  40.  
  41. /* $02 ILLEGAL */
  42.  
  43. /* $03 ILLEGAL */
  44.  
  45. /* $04 LSRD inherent -0*-* */
  46. INLINE void lsrd (void)
  47. {
  48.     UINT16 t;
  49.     CLR_NZC; t = D; CC|=(t&0x0001);
  50.     t>>=1; SET_Z16(t); D=t;
  51. }
  52.  
  53. /* $05 ASLD inherent ?**** */
  54. INLINE void asld (void)
  55. {
  56.     int r;
  57.     UINT16 t;
  58.     t = D; r=t<<1;
  59.     CLR_NZVC; SET_FLAGS16(t,t,r);
  60.     D=r;
  61. }
  62.  
  63. /* $06 TAP inherent ##### */
  64. INLINE void tap (void)
  65. {
  66.     CC=A;
  67.     ONE_MORE_INSN();
  68.     CHECK_IRQ_LINES(); /* HJB 990417 */
  69. }
  70.  
  71. /* $07 TPA inherent ----- */
  72. INLINE void tpa (void)
  73. {
  74.     A=CC;
  75. }
  76.  
  77. /* $08 INX inherent --*-- */
  78. INLINE void inx (void)
  79. {
  80.     ++X;
  81.     CLR_Z; SET_Z16(X);
  82. }
  83.  
  84. /* $09 DEX inherent --*-- */
  85. INLINE void dex (void)
  86. {
  87.     --X;
  88.     CLR_Z; SET_Z16(X);
  89. }
  90.  
  91. /* $0a CLV */
  92. INLINE void clv (void)
  93. {
  94.     CLV;
  95. }
  96.  
  97. /* $0b SEV */
  98. INLINE void sev (void)
  99. {
  100.     SEV;
  101. }
  102.  
  103. /* $0c CLC */
  104. INLINE void clc (void)
  105. {
  106.     CLC;
  107. }
  108.  
  109. /* $0d SEC */
  110. INLINE void sec (void)
  111. {
  112.     SEC;
  113. }
  114.  
  115. /* $0e CLI */
  116. INLINE void cli (void)
  117. {
  118.     CLI;
  119.     ONE_MORE_INSN();
  120.     CHECK_IRQ_LINES(); /* HJB 990417 */
  121. }
  122.  
  123. /* $0f SEI */
  124. INLINE void sei (void)
  125. {
  126.     SEI;
  127.     ONE_MORE_INSN();
  128.     CHECK_IRQ_LINES(); /* HJB 990417 */
  129. }
  130.  
  131. #if macintosh
  132. #pragma mark ____1x____
  133. #endif
  134.  
  135. /* $10 SBA inherent -**** */
  136. INLINE void sba (void)
  137. {
  138.     UINT16 t;
  139.     t=A-B;
  140.     CLR_NZVC; SET_FLAGS8(A,B,t);
  141.     A=t;
  142. }
  143.  
  144. /* $11 CBA inherent -**** */
  145. INLINE void cba (void)
  146. {
  147.     UINT16 t;
  148.     t=A-B;
  149.     CLR_NZVC; SET_FLAGS8(A,B,t);
  150. }
  151.  
  152. /* $12 ILLEGAL */
  153. INLINE void undoc1 (void)
  154. {
  155.     X += RM( S + 1 );
  156. }
  157.  
  158. /* $13 ILLEGAL */
  159. INLINE void undoc2 (void)
  160. {
  161.     X += RM( S + 1 );
  162. }
  163.  
  164.  
  165. /* $14 ILLEGAL */
  166.  
  167. /* $15 ILLEGAL */
  168.  
  169. /* $16 TAB inherent -**0- */
  170. INLINE void tab (void)
  171. {
  172.     B=A;
  173.     CLR_NZV; SET_NZ8(B);
  174. }
  175.  
  176. /* $17 TBA inherent -**0- */
  177. INLINE void tba (void)
  178. {
  179.     A=B;
  180.     CLR_NZV; SET_NZ8(A);
  181. }
  182.  
  183. /* $18 XGDX inherent ----- */ /* HD63701YO only */
  184. INLINE void xgdx( void )
  185. {
  186.     UINT16 t = X;
  187.     X = D;
  188.     D=t;
  189. }
  190.  
  191. /* $19 DAA inherent (A) -**0* */
  192. INLINE void daa( void )
  193. {
  194.     UINT8 msn, lsn;
  195.     UINT16 t, cf = 0;
  196.     msn=A & 0xf0; lsn=A & 0x0f;
  197.     if( lsn>0x09 || CC&0x20 ) cf |= 0x06;
  198.     if( msn>0x80 && lsn>0x09 ) cf |= 0x60;
  199.     if( msn>0x90 || CC&0x01 ) cf |= 0x60;
  200.     t = cf + A;
  201.     CLR_NZV; /* keep carry from previous operation */
  202.     SET_NZ8((UINT8)t); SET_C8(t);
  203.     A = t;
  204. }
  205.  
  206. /* $1a ILLEGAL */
  207.  
  208. #if (HAS_HD63701)
  209. /* $1a SLP */ /* HD63701YO only */
  210. INLINE void slp (void)
  211. {
  212.     /* wait for next IRQ (same as waiting of wai) */
  213.     m6808.wai_state |= HD63701_SLP;
  214.     EAT_CYCLES;
  215. }
  216. #endif
  217.  
  218. /* $1b ABA inherent ***** */
  219. INLINE void aba (void)
  220. {
  221.     UINT16 t;
  222.     t=A+B;
  223.     CLR_HNZVC; SET_FLAGS8(A,B,t); SET_H(A,B,t);
  224.     A=t;
  225. }
  226.  
  227. /* $1c ILLEGAL */
  228.  
  229. /* $1d ILLEGAL */
  230.  
  231. /* $1e ILLEGAL */
  232.  
  233. /* $1f ILLEGAL */
  234.  
  235. #if macintosh
  236. #pragma mark ____2x____
  237. #endif
  238.  
  239. /* $20 BRA relative ----- */
  240. INLINE void bra( void )
  241. {
  242.     UINT8 t;
  243.     IMMBYTE(t);PC+=SIGNED(t);CHANGE_PC();
  244.     /* speed up busy loops */
  245.     if (t==0xfe) EAT_CYCLES;
  246. }
  247.  
  248. /* $21 BRN relative ----- */
  249. INLINE void brn( void )
  250. {
  251.     UINT8 t;
  252.     IMMBYTE(t);
  253. }
  254.  
  255. /* $22 BHI relative ----- */
  256. INLINE void bhi( void )
  257. {
  258.     UINT8 t;
  259.     BRANCH(!(CC&0x05));
  260. }
  261.  
  262. /* $23 BLS relative ----- */
  263. INLINE void bls( void )
  264. {
  265.     UINT8 t;
  266.     BRANCH(CC&0x05);
  267. }
  268.  
  269. /* $24 BCC relative ----- */
  270. INLINE void bcc( void )
  271. {
  272.     UINT8 t;
  273.     BRANCH(!(CC&0x01));
  274. }
  275.  
  276. /* $25 BCS relative ----- */
  277. INLINE void bcs( void )
  278. {
  279.     UINT8 t;
  280.     BRANCH(CC&0x01);
  281. }
  282.  
  283. /* $26 BNE relative ----- */
  284. INLINE void bne( void )
  285. {
  286.     UINT8 t;
  287.     BRANCH(!(CC&0x04));
  288. }
  289.  
  290. /* $27 BEQ relative ----- */
  291. INLINE void beq( void )
  292. {
  293.     UINT8 t;
  294.     BRANCH(CC&0x04);
  295. }
  296.  
  297. /* $28 BVC relative ----- */
  298. INLINE void bvc( void )
  299. {
  300.     UINT8 t;
  301.     BRANCH(!(CC&0x02));
  302. }
  303.  
  304. /* $29 BVS relative ----- */
  305. INLINE void bvs( void )
  306. {
  307.     UINT8 t;
  308.     BRANCH(CC&0x02);
  309. }
  310.  
  311. /* $2a BPL relative ----- */
  312. INLINE void bpl( void )
  313. {
  314.     UINT8 t;
  315.     BRANCH(!(CC&0x08));
  316. }
  317.  
  318. /* $2b BMI relative ----- */
  319. INLINE void bmi( void )
  320. {
  321.     UINT8 t;
  322.     BRANCH(CC&0x08);
  323. }
  324.  
  325. /* $2c BGE relative ----- */
  326. INLINE void bge( void )
  327. {
  328.     UINT8 t;
  329.     BRANCH(!NXORV);
  330. }
  331.  
  332. /* $2d BLT relative ----- */
  333. INLINE void blt( void )
  334. {
  335.     UINT8 t;
  336.     BRANCH(NXORV);
  337. }
  338.  
  339. /* $2e BGT relative ----- */
  340. INLINE void bgt( void )
  341. {
  342.     UINT8 t;
  343.     BRANCH(!(NXORV||CC&0x04));
  344. }
  345.  
  346. /* $2f BLE relative ----- */
  347. INLINE void ble( void )
  348. {
  349.     UINT8 t;
  350.     BRANCH(NXORV||CC&0x04);
  351. }
  352.  
  353.  
  354. #if macintosh
  355. #pragma mark ____3x____
  356. #endif
  357.  
  358. /* $30 TSX inherent ----- */
  359. INLINE void tsx (void)
  360. {
  361.     X = ( S + 1 );
  362. }
  363.  
  364. /* $31 INS inherent ----- */
  365. INLINE void ins (void)
  366. {
  367.     ++S;
  368. }
  369.  
  370. /* $32 PULA inherent ----- */
  371. INLINE void pula (void)
  372. {
  373.     PULLBYTE(m6808.d.b.h);
  374. }
  375.  
  376. /* $33 PULB inherent ----- */
  377. INLINE void pulb (void)
  378. {
  379.     PULLBYTE(m6808.d.b.l);
  380. }
  381.  
  382. /* $34 DES inherent ----- */
  383. INLINE void des (void)
  384. {
  385.     --S;
  386. }
  387.  
  388. /* $35 TXS inherent ----- */
  389. INLINE void txs (void)
  390. {
  391.     S = ( X - 1 );
  392. }
  393.  
  394. /* $36 PSHA inherent ----- */
  395. INLINE void psha (void)
  396. {
  397.     PUSHBYTE(m6808.d.b.h);
  398. }
  399.  
  400. /* $37 PSHB inherent ----- */
  401. INLINE void pshb (void)
  402. {
  403.     PUSHBYTE(m6808.d.b.l);
  404. }
  405.  
  406. /* $38 PULX inherent ----- */
  407. INLINE void pulx (void)
  408. {
  409.     PULLWORD(pX);
  410. }
  411.  
  412. /* $39 RTS inherent ----- */
  413. INLINE void rts( void )
  414. {
  415.     PULLWORD(pPC);
  416.     CHANGE_PC();
  417. }
  418.  
  419. /* $3a ABX inherent ----- */
  420. INLINE void abx( void )
  421. {
  422.     X += B;
  423. }
  424.  
  425. /* $3b RTI inherent ##### */
  426. INLINE void rti( void )
  427. {
  428.     PULLBYTE(CC);
  429.     PULLBYTE(B);
  430.     PULLBYTE(A);
  431.     PULLWORD(pX);
  432.     PULLWORD(pPC);
  433.     CHANGE_PC();
  434.     CHECK_IRQ_LINES(); /* HJB 990417 */
  435. }
  436.  
  437. /* $3c PSHX inherent ----- */
  438. INLINE void pshx (void)
  439. {
  440.     PUSHWORD(pX);
  441. }
  442.  
  443. /* $3d MUL inherent --*-@ */
  444. INLINE void mul( void )
  445. {
  446.     UINT16 t;
  447.     t=A*B;
  448.     CLR_C; if(t&0x80) SEC;
  449.     D=t;
  450. }
  451.  
  452. /* $3e WAI inherent ----- */
  453. INLINE void wai( void )
  454. {
  455.     /*
  456.      * WAI stacks the entire machine state on the
  457.      * hardware stack, then waits for an interrupt.
  458.      */
  459.     m6808.wai_state |= M6808_WAI;
  460.     PUSHWORD(pPC);
  461.     PUSHWORD(pX);
  462.     PUSHBYTE(A);
  463.     PUSHBYTE(B);
  464.     PUSHBYTE(CC);
  465.     CHECK_IRQ_LINES();
  466.     if (m6808.wai_state & M6808_WAI) EAT_CYCLES;
  467. }
  468.  
  469. /* $3f SWI absolute indirect ----- */
  470. INLINE void swi( void )
  471. {
  472.     PUSHWORD(pPC);
  473.     PUSHWORD(pX);
  474.     PUSHBYTE(A);
  475.     PUSHBYTE(B);
  476.     PUSHBYTE(CC);
  477.     SEI;
  478.     PCD = RM16(0xfffa);
  479.     CHANGE_PC();
  480. }
  481.  
  482. #if macintosh
  483. #pragma mark ____4x____
  484. #endif
  485.  
  486. /* $40 NEGA inherent ?**** */
  487. INLINE void nega( void )
  488. {
  489.     UINT16 r;
  490.     r=-A;
  491.     CLR_NZVC; SET_FLAGS8(0,A,r);
  492.     A=r;
  493. }
  494.  
  495. /* $41 ILLEGAL */
  496.  
  497. /* $42 ILLEGAL */
  498.  
  499. /* $43 COMA inherent -**01 */
  500. INLINE void coma( void )
  501. {
  502.     A = ~A;
  503.     CLR_NZV; SET_NZ8(A); SEC;
  504. }
  505.  
  506. /* $44 LSRA inherent -0*-* */
  507. INLINE void lsra( void )
  508. {
  509.     CLR_NZC; CC|=(A&0x01);
  510.     A>>=1; SET_Z8(A);
  511. }
  512.  
  513. /* $45 ILLEGAL */
  514.  
  515. /* $46 RORA inherent -**-* */
  516. INLINE void rora( void )
  517. {
  518.     UINT8 r;
  519.     r=(CC&0x01)<<7;
  520.     CLR_NZC; CC|=(A&0x01);
  521.     r |= A>>1; SET_NZ8(r);
  522.     A=r;
  523. }
  524.  
  525. /* $47 ASRA inherent ?**-* */
  526. INLINE void asra( void )
  527. {
  528.     CLR_NZC; CC|=(A&0x01);
  529.     A>>=1; A|=((A&0x40)<<1);
  530.     SET_NZ8(A);
  531. }
  532.  
  533. /* $48 ASLA inherent ?**** */
  534. INLINE void asla( void )
  535. {
  536.     UINT16 r;
  537.     r=A<<1;
  538.     CLR_NZVC; SET_FLAGS8(A,A,r);
  539.     A=r;
  540. }
  541.  
  542. /* $49 ROLA inherent -**** */
  543. INLINE void rola( void )
  544. {
  545.     UINT16 t,r;
  546.     t = A; r = CC&0x01; r |= t<<1;
  547.     CLR_NZVC; SET_FLAGS8(t,t,r);
  548.     A=r;
  549. }
  550.  
  551. /* $4a DECA inherent -***- */
  552. INLINE void deca( void )
  553. {
  554.     --A;
  555.     CLR_NZV; SET_FLAGS8D(A);
  556. }
  557.  
  558. /* $4b ILLEGAL */
  559.  
  560. /* $4c INCA inherent -***- */
  561. INLINE void inca( void )
  562. {
  563.     ++A;
  564.     CLR_NZV; SET_FLAGS8I(A);
  565. }
  566.  
  567. /* $4d TSTA inherent -**0- */
  568. INLINE void tsta( void )
  569. {
  570.     CLR_NZVC; SET_NZ8(A);
  571. }
  572.  
  573. /* $4e ILLEGAL */
  574.  
  575. /* $4f CLRA inherent -0100 */
  576. INLINE void clra( void )
  577. {
  578.     A=0;
  579.     CLR_NZVC; SEZ;
  580. }
  581.  
  582.  
  583. #if macintosh
  584. #pragma mark ____5x____
  585. #endif
  586.  
  587.  
  588. /* $50 NEGB inherent ?**** */
  589. INLINE void negb( void )
  590. {
  591.     UINT16 r;
  592.     r=-B;
  593.     CLR_NZVC; SET_FLAGS8(0,B,r);
  594.     B=r;
  595. }
  596.  
  597. /* $51 ILLEGAL */
  598.  
  599. /* $52 ILLEGAL */
  600.  
  601. /* $53 COMB inherent -**01 */
  602. INLINE void comb( void )
  603. {
  604.     B = ~B;
  605.     CLR_NZV; SET_NZ8(B); SEC;
  606. }
  607.  
  608. /* $54 LSRB inherent -0*-* */
  609. INLINE void lsrb( void )
  610. {
  611.     CLR_NZC; CC|=(B&0x01);
  612.     B>>=1; SET_Z8(B);
  613. }
  614.  
  615. /* $55 ILLEGAL */
  616.  
  617. /* $56 RORB inherent -**-* */
  618. INLINE void rorb( void )
  619. {
  620.     UINT8 r;
  621.     r=(CC&0x01)<<7;
  622.     CLR_NZC; CC|=(B&0x01);
  623.     r |= B>>1; SET_NZ8(r);
  624.     B=r;
  625. }
  626.  
  627. /* $57 ASRB inherent ?**-* */
  628. INLINE void asrb( void )
  629. {
  630.     CLR_NZC; CC|=(B&0x01);
  631.     B>>=1; B|=((B&0x40)<<1);
  632.     SET_NZ8(B);
  633. }
  634.  
  635. /* $58 ASLB inherent ?**** */
  636. INLINE void aslb( void )
  637. {
  638.     UINT16 r;
  639.     r=B<<1;
  640.     CLR_NZVC; SET_FLAGS8(B,B,r);
  641.     B=r;
  642. }
  643.  
  644. /* $59 ROLB inherent -**** */
  645. INLINE void rolb( void )
  646. {
  647.     UINT16 t,r;
  648.     t = B; r = CC&0x01; r |= t<<1;
  649.     CLR_NZVC; SET_FLAGS8(t,t,r);
  650.     B=r;
  651. }
  652.  
  653. /* $5a DECB inherent -***- */
  654. INLINE void decb( void )
  655. {
  656.     --B;
  657.     CLR_NZV; SET_FLAGS8D(B);
  658. }
  659.  
  660. /* $5b ILLEGAL */
  661.  
  662. /* $5c INCB inherent -***- */
  663. INLINE void incb( void )
  664. {
  665.     ++B;
  666.     CLR_NZV; SET_FLAGS8I(B);
  667. }
  668.  
  669. /* $5d TSTB inherent -**0- */
  670. INLINE void tstb( void )
  671. {
  672.     CLR_NZVC; SET_NZ8(B);
  673. }
  674.  
  675. /* $5e ILLEGAL */
  676.  
  677. /* $5f CLRB inherent -0100 */
  678. INLINE void clrb( void )
  679. {
  680.     B=0;
  681.     CLR_NZVC; SEZ;
  682. }
  683.  
  684. #if macintosh
  685. #pragma mark ____6x____
  686. #endif
  687.  
  688. /* $60 NEG indexed ?**** */
  689. INLINE void neg_ix( void )
  690. {
  691.     UINT16 r,t;
  692.     IDXBYTE(t); r=-t;
  693.     CLR_NZVC; SET_FLAGS8(0,t,r);
  694.     WM(EAD,r);
  695. }
  696.  
  697. /* $61 AIM --**0- */ /* HD63701YO only */
  698. INLINE void aim_ix( void )
  699. {
  700.     UINT8 t, r;
  701.     IMMBYTE(t);
  702.     IDXBYTE(r);
  703.     r &= t;
  704.     CLR_NZV; SET_NZ8(r);
  705.     WM(EAD,r);
  706. }
  707.  
  708. /* $62 OIM --**0- */ /* HD63701YO only */
  709. INLINE void oim_ix( void )
  710. {
  711.     UINT8 t, r;
  712.     IMMBYTE(t);
  713.     IDXBYTE(r);
  714.     r |= t;
  715.     CLR_NZV; SET_NZ8(r);
  716.     WM(EAD,r);
  717. }
  718.  
  719. /* $63 COM indexed -**01 */
  720. INLINE void com_ix( void )
  721. {
  722.     UINT8 t;
  723.     IDXBYTE(t); t = ~t;
  724.     CLR_NZV; SET_NZ8(t); SEC;
  725.     WM(EAD,t);
  726. }
  727.  
  728. /* $64 LSR indexed -0*-* */
  729. INLINE void lsr_ix( void )
  730. {
  731.     UINT8 t;
  732.     IDXBYTE(t); CLR_NZC; CC|=(t&0x01);
  733.     t>>=1; SET_Z8(t);
  734.     WM(EAD,t);
  735. }
  736.  
  737. /* $65 EIM --**0- */ /* HD63701YO only */
  738. INLINE void eim_ix( void )
  739. {
  740.     UINT8 t, r;
  741.     IMMBYTE(t);
  742.     IDXBYTE(r);
  743.     r ^= t;
  744.     CLR_NZV; SET_NZ8(r);
  745.     WM(EAD,r);
  746. }
  747.  
  748. /* $66 ROR indexed -**-* */
  749. INLINE void ror_ix( void )
  750. {
  751.     UINT8 t,r;
  752.     IDXBYTE(t); r=(CC&0x01)<<7;
  753.     CLR_NZC; CC|=(t&0x01);
  754.     r |= t>>1; SET_NZ8(r);
  755.     WM(EAD,r);
  756. }
  757.  
  758. /* $67 ASR indexed ?**-* */
  759. INLINE void asr_ix( void )
  760. {
  761.     UINT8 t;
  762.     IDXBYTE(t); CLR_NZC; CC|=(t&0x01);
  763.     t>>=1; t|=((t&0x40)<<1);
  764.     SET_NZ8(t);
  765.     WM(EAD,t);
  766. }
  767.  
  768. /* $68 ASL indexed ?**** */
  769. INLINE void asl_ix( void )
  770. {
  771.     UINT16 t,r;
  772.     IDXBYTE(t); r=t<<1;
  773.     CLR_NZVC; SET_FLAGS8(t,t,r);
  774.     WM(EAD,r);
  775. }
  776.  
  777. /* $69 ROL indexed -**** */
  778. INLINE void rol_ix( void )
  779. {
  780.     UINT16 t,r;
  781.     IDXBYTE(t); r = CC&0x01; r |= t<<1;
  782.     CLR_NZVC; SET_FLAGS8(t,t,r);
  783.     WM(EAD,r);
  784. }
  785.  
  786. /* $6a DEC indexed -***- */
  787. INLINE void dec_ix( void )
  788. {
  789.     UINT8 t;
  790.     IDXBYTE(t); --t;
  791.     CLR_NZV; SET_FLAGS8D(t);
  792.     WM(EAD,t);
  793. }
  794.  
  795. /* $6b TIM --**0- */ /* HD63701YO only */
  796. INLINE void tim_ix( void )
  797. {
  798.     UINT8 t, r;
  799.     IMMBYTE(t);
  800.     IDXBYTE(r);
  801.     r &= t;
  802.     CLR_NZV; SET_NZ8(r);
  803. }
  804.  
  805. /* $6c INC indexed -***- */
  806. INLINE void inc_ix( void )
  807. {
  808.     UINT8 t;
  809.     IDXBYTE(t); ++t;
  810.     CLR_NZV; SET_FLAGS8I(t);
  811.     WM(EAD,t);
  812. }
  813.  
  814. /* $6d TST indexed -**0- */
  815. INLINE void tst_ix( void )
  816. {
  817.     UINT8 t;
  818.     IDXBYTE(t); CLR_NZVC; SET_NZ8(t);
  819. }
  820.  
  821. /* $6e JMP indexed ----- */
  822. INLINE void jmp_ix( void )
  823. {
  824.     INDEXED; PC=EA; CHANGE_PC();
  825. }
  826.  
  827. /* $6f CLR indexed -0100 */
  828. INLINE void clr_ix( void )
  829. {
  830.     INDEXED; WM(EAD,0);
  831.     CLR_NZVC; SEZ;
  832. }
  833.  
  834. #if macintosh
  835. #pragma mark ____7x____
  836. #endif
  837.  
  838. /* $70 NEG extended ?**** */
  839. INLINE void neg_ex( void )
  840. {
  841.     UINT16 r,t;
  842.     EXTBYTE(t); r=-t;
  843.     CLR_NZVC; SET_FLAGS8(0,t,r);
  844.     WM(EAD,r);
  845. }
  846.  
  847. /* $71 AIM --**0- */ /* HD63701YO only */
  848. INLINE void aim_di( void )
  849. {
  850.     UINT8 t, r;
  851.     IMMBYTE(t);
  852.     DIRBYTE(r);
  853.     r &= t;
  854.     CLR_NZV; SET_NZ8(r);
  855.     WM(EAD,r);
  856. }
  857.  
  858. /* $72 OIM --**0- */ /* HD63701YO only */
  859. INLINE void oim_di( void )
  860. {
  861.     UINT8 t, r;
  862.     IMMBYTE(t);
  863.     DIRBYTE(r);
  864.     r |= t;
  865.     CLR_NZV; SET_NZ8(r);
  866.     WM(EAD,r);
  867. }
  868.  
  869. /* $73 COM extended -**01 */
  870. INLINE void com_ex( void )
  871. {
  872.     UINT8 t;
  873.     EXTBYTE(t); t = ~t;
  874.     CLR_NZV; SET_NZ8(t); SEC;
  875.     WM(EAD,t);
  876. }
  877.  
  878. /* $74 LSR extended -0*-* */
  879. INLINE void lsr_ex( void )
  880. {
  881.     UINT8 t;
  882.     EXTBYTE(t);
  883.     CLR_NZC;
  884.     CC|=(t&0x01);
  885.     t>>=1;
  886.     SET_Z8(t);
  887.     WM(EAD,t);
  888. }
  889.  
  890. /* $75 EIM --**0- */ /* HD63701YO only */
  891. INLINE void eim_di( void )
  892. {
  893.     UINT8 t, r;
  894.     IMMBYTE(t);
  895.     DIRBYTE(r);
  896.     r ^= t;
  897.     CLR_NZV; SET_NZ8(r);
  898.     WM(EAD,r);
  899. }
  900.  
  901. /* $76 ROR extended -**-* */
  902. INLINE void ror_ex( void )
  903. {
  904.     UINT8 t,r;
  905.     EXTBYTE(t); r=(CC&0x01)<<7;
  906.     CLR_NZC; CC|=(t&0x01);
  907.     r |= t>>1; SET_NZ8(r);
  908.     WM(EAD,r);
  909. }
  910.  
  911. /* $77 ASR extended ?**-* */
  912. INLINE void asr_ex( void )
  913. {
  914.     UINT8 t;
  915.     EXTBYTE(t); CLR_NZC; CC|=(t&0x01);
  916.     t>>=1; t|=((t&0x40)<<1);
  917.     SET_NZ8(t);
  918.     WM(EAD,t);
  919. }
  920.  
  921. /* $78 ASL extended ?**** */
  922. INLINE void asl_ex( void )
  923. {
  924.     UINT16 t,r;
  925.     EXTBYTE(t); r=t<<1;
  926.     CLR_NZVC; SET_FLAGS8(t,t,r);
  927.     WM(EAD,r);
  928. }
  929.  
  930. /* $79 ROL extended -**** */
  931. INLINE void rol_ex( void )
  932. {
  933.     UINT16 t,r;
  934.     EXTBYTE(t); r = CC&0x01; r |= t<<1;
  935.     CLR_NZVC; SET_FLAGS8(t,t,r);
  936.     WM(EAD,r);
  937. }
  938.  
  939. /* $7a DEC extended -***- */
  940. INLINE void dec_ex( void )
  941. {
  942.     UINT8 t;
  943.     EXTBYTE(t); --t;
  944.     CLR_NZV; SET_FLAGS8D(t);
  945.     WM(EAD,t);
  946. }
  947.  
  948. /* $7b TIM --**0- */ /* HD63701YO only */
  949. INLINE void tim_di( void )
  950. {
  951.     UINT8 t, r;
  952.     IMMBYTE(t);
  953.     DIRBYTE(r);
  954.     r &= t;
  955.     CLR_NZV; SET_NZ8(r);
  956. }
  957.  
  958. /* $7c INC extended -***- */
  959. INLINE void inc_ex( void )
  960. {
  961.     UINT8 t;
  962.     EXTBYTE(t); ++t;
  963.     CLR_NZV; SET_FLAGS8I(t);
  964.     WM(EAD,t);
  965. }
  966.  
  967. /* $7d TST extended -**0- */
  968. INLINE void tst_ex( void )
  969. {
  970.     UINT8 t;
  971.     EXTBYTE(t); CLR_NZVC; SET_NZ8(t);
  972. }
  973.  
  974. /* $7e JMP extended ----- */
  975. INLINE void jmp_ex( void )
  976. {
  977.     EXTENDED; PC=EA; CHANGE_PC(); /* TS 971002 */
  978. }
  979.  
  980. /* $7f CLR extended -0100 */
  981. INLINE void clr_ex( void )
  982. {
  983.     EXTENDED; WM(EAD,0);
  984.     CLR_NZVC; SEZ;
  985. }
  986.  
  987.  
  988. #if macintosh
  989. #pragma mark ____8x____
  990. #endif
  991.  
  992. /* $80 SUBA immediate ?**** */
  993. INLINE void suba_im( void )
  994. {
  995.     UINT16      t,r;
  996.     IMMBYTE(t); r = A-t;
  997.     CLR_NZVC; SET_FLAGS8(A,t,r);
  998.     A = r;
  999. }
  1000.  
  1001. /* $81 CMPA immediate ?**** */
  1002. INLINE void cmpa_im( void )
  1003. {
  1004.     UINT16      t,r;
  1005.     IMMBYTE(t); r = A-t;
  1006.     CLR_NZVC; SET_FLAGS8(A,t,r);
  1007. }
  1008.  
  1009. /* $82 SBCA immediate ?**** */
  1010. INLINE void sbca_im( void )
  1011. {
  1012.     UINT16      t,r;
  1013.     IMMBYTE(t); r = A-t-(CC&0x01);
  1014.     CLR_NZVC; SET_FLAGS8(A,t,r);
  1015.     A = r;
  1016. }
  1017.  
  1018. /* $83 SUBD immediate -**** */
  1019. INLINE void subd_im( void )
  1020. {
  1021.     UINT32 r,d;
  1022.     PAIR b;
  1023.     IMMWORD(b);
  1024.     d = D;
  1025.     r = d - b.d;
  1026.     CLR_NZVC;
  1027.     SET_FLAGS16(d,b.d,r);
  1028.     D = r;
  1029. }
  1030.  
  1031. /* $84 ANDA immediate -**0- */
  1032. INLINE void anda_im( void )
  1033. {
  1034.     UINT8 t;
  1035.     IMMBYTE(t); A &= t;
  1036.     CLR_NZV; SET_NZ8(A);
  1037. }
  1038.  
  1039. /* $85 BITA immediate -**0- */
  1040. INLINE void bita_im( void )
  1041. {
  1042.     UINT8 t,r;
  1043.     IMMBYTE(t); r = A&t;
  1044.     CLR_NZV; SET_NZ8(r);
  1045. }
  1046.  
  1047. /* $86 LDA immediate -**0- */
  1048. INLINE void lda_im( void )
  1049. {
  1050.     IMMBYTE(A);
  1051.     CLR_NZV; SET_NZ8(A);
  1052. }
  1053.  
  1054. /* is this a legal instruction? */
  1055. /* $87 STA immediate -**0- */
  1056. INLINE void sta_im( void )
  1057. {
  1058.     CLR_NZV; SET_NZ8(A);
  1059.     IMM8; WM(EAD,A);
  1060. }
  1061.  
  1062. /* $88 EORA immediate -**0- */
  1063. INLINE void eora_im( void )
  1064. {
  1065.     UINT8 t;
  1066.     IMMBYTE(t); A ^= t;
  1067.     CLR_NZV; SET_NZ8(A);
  1068. }
  1069.  
  1070. /* $89 ADCA immediate ***** */
  1071. INLINE void adca_im( void )
  1072. {
  1073.     UINT16 t,r;
  1074.     IMMBYTE(t); r = A+t+(CC&0x01);
  1075.     CLR_HNZVC; SET_FLAGS8(A,t,r); SET_H(A,t,r);
  1076.     A = r;
  1077. }
  1078.  
  1079. /* $8a ORA immediate -**0- */
  1080. INLINE void ora_im( void )
  1081. {
  1082.     UINT8 t;
  1083.     IMMBYTE(t); A |= t;
  1084.     CLR_NZV; SET_NZ8(A);
  1085. }
  1086.  
  1087. /* $8b ADDA immediate ***** */
  1088. INLINE void adda_im( void )
  1089. {
  1090.     UINT16 t,r;
  1091.     IMMBYTE(t); r = A+t;
  1092.     CLR_HNZVC; SET_FLAGS8(A,t,r); SET_H(A,t,r);
  1093.     A = r;
  1094. }
  1095.  
  1096. /* $8c CMPX immediate -***- */
  1097. INLINE void cmpx_im( void )
  1098. {
  1099.     UINT32 r,d;
  1100.     PAIR b;
  1101.     IMMWORD(b);
  1102.     d = X;
  1103.     r = d - b.d;
  1104.     CLR_NZV;
  1105.     SET_NZ16(r); SET_V16(d,b.d,r);
  1106. }
  1107.  
  1108. /* $8c CPX immediate -**** (6803) */
  1109. INLINE void cpx_im( void )
  1110. {
  1111.     UINT32 r,d;
  1112.     PAIR b;
  1113.     IMMWORD(b);
  1114.     d = X;
  1115.     r = d - b.d;
  1116.     CLR_NZVC; SET_FLAGS16(d,b.d,r);
  1117. }
  1118.  
  1119.  
  1120. /* $8d BSR ----- */
  1121. INLINE void bsr( void )
  1122. {
  1123.     UINT8 t;
  1124.     IMMBYTE(t);
  1125.     PUSHWORD(pPC);
  1126.     PC += SIGNED(t);
  1127.     CHANGE_PC();     /* TS 971002 */
  1128. }
  1129.  
  1130. /* $8e LDS immediate -**0- */
  1131. INLINE void lds_im( void )
  1132. {
  1133.     IMMWORD(m6808.s);
  1134.     CLR_NZV;
  1135.     SET_NZ16(S);
  1136. }
  1137.  
  1138. /* $8f STS immediate -**0- */
  1139. INLINE void sts_im( void )
  1140. {
  1141.     CLR_NZV;
  1142.     SET_NZ16(S);
  1143.     IMM16;
  1144.     WM16(EAD,&m6808.s);
  1145. }
  1146.  
  1147. #if macintosh
  1148. #pragma mark ____9x____
  1149. #endif
  1150.  
  1151. /* $90 SUBA direct ?**** */
  1152. INLINE void suba_di( void )
  1153. {
  1154.     UINT16      t,r;
  1155.     DIRBYTE(t); r = A-t;
  1156.     CLR_NZVC; SET_FLAGS8(A,t,r);
  1157.     A = r;
  1158. }
  1159.  
  1160. /* $91 CMPA direct ?**** */
  1161. INLINE void cmpa_di( void )
  1162. {
  1163.     UINT16      t,r;
  1164.     DIRBYTE(t); r = A-t;
  1165.     CLR_NZVC; SET_FLAGS8(A,t,r);
  1166. }
  1167.  
  1168. /* $92 SBCA direct ?**** */
  1169. INLINE void sbca_di( void )
  1170. {
  1171.     UINT16      t,r;
  1172.     DIRBYTE(t); r = A-t-(CC&0x01);
  1173.     CLR_NZVC; SET_FLAGS8(A,t,r);
  1174.     A = r;
  1175. }
  1176.  
  1177. /* $93 SUBD direct -**** */
  1178. INLINE void subd_di( void )
  1179. {
  1180.     UINT32 r,d;
  1181.     PAIR b;
  1182.     DIRWORD(b);
  1183.     d = D;
  1184.     r = d - b.d;
  1185.     CLR_NZVC;
  1186.     SET_FLAGS16(d,b.d,r);
  1187.     D=r;
  1188. }
  1189.  
  1190. /* $94 ANDA direct -**0- */
  1191. INLINE void anda_di( void )
  1192. {
  1193.     UINT8 t;
  1194.     DIRBYTE(t); A &= t;
  1195.     CLR_NZV; SET_NZ8(A);
  1196. }
  1197.  
  1198. /* $95 BITA direct -**0- */
  1199. INLINE void bita_di( void )
  1200. {
  1201.     UINT8 t,r;
  1202.     DIRBYTE(t); r = A&t;
  1203.     CLR_NZV; SET_NZ8(r);
  1204. }
  1205.  
  1206. /* $96 LDA direct -**0- */
  1207. INLINE void lda_di( void )
  1208. {
  1209.     DIRBYTE(A);
  1210.     CLR_NZV; SET_NZ8(A);
  1211. }
  1212.  
  1213. /* $97 STA direct -**0- */
  1214. INLINE void sta_di( void )
  1215. {
  1216.     CLR_NZV; SET_NZ8(A);
  1217.     DIRECT; WM(EAD,A);
  1218. }
  1219.  
  1220. /* $98 EORA direct -**0- */
  1221. INLINE void eora_di( void )
  1222. {
  1223.     UINT8 t;
  1224.     DIRBYTE(t); A ^= t;
  1225.     CLR_NZV; SET_NZ8(A);
  1226. }
  1227.  
  1228. /* $99 ADCA direct ***** */
  1229. INLINE void adca_di( void )
  1230. {
  1231.     UINT16 t,r;
  1232.     DIRBYTE(t); r = A+t+(CC&0x01);
  1233.     CLR_HNZVC; SET_FLAGS8(A,t,r); SET_H(A,t,r);
  1234.     A = r;
  1235. }
  1236.  
  1237. /* $9a ORA direct -**0- */
  1238. INLINE void ora_di( void )
  1239. {
  1240.     UINT8 t;
  1241.     DIRBYTE(t); A |= t;
  1242.     CLR_NZV; SET_NZ8(A);
  1243. }
  1244.  
  1245. /* $9b ADDA direct ***** */
  1246. INLINE void adda_di( void )
  1247. {
  1248.     UINT16 t,r;
  1249.     DIRBYTE(t); r = A+t;
  1250.     CLR_HNZVC; SET_FLAGS8(A,t,r); SET_H(A,t,r);
  1251.     A = r;
  1252. }
  1253.  
  1254. /* $9c CMPX direct -***- */
  1255. INLINE void cmpx_di( void )
  1256. {
  1257.     UINT32 r,d;
  1258.     PAIR b;
  1259.     DIRWORD(b);
  1260.     d = X;
  1261.     r = d - b.d;
  1262.     CLR_NZV;
  1263.     SET_NZ16(r); SET_V16(d,b.d,r);
  1264. }
  1265.  
  1266. /* $9c CPX direct -**** (6803) */
  1267. INLINE void cpx_di( void )
  1268. {
  1269.     UINT32 r,d;
  1270.     PAIR b;
  1271.     DIRWORD(b);
  1272.     d = X;
  1273.     r = d - b.d;
  1274.     CLR_NZVC; SET_FLAGS16(d,b.d,r);
  1275. }
  1276.  
  1277. /* $9d JSR direct ----- */
  1278. INLINE void jsr_di( void )
  1279. {
  1280.     DIRECT;
  1281.     PUSHWORD(pPC);
  1282.     PC = EA;
  1283.     CHANGE_PC();
  1284. }
  1285.  
  1286. /* $9e LDS direct -**0- */
  1287. INLINE void lds_di( void )
  1288. {
  1289.     DIRWORD(m6808.s);
  1290.     CLR_NZV;
  1291.     SET_NZ16(S);
  1292. }
  1293.  
  1294. /* $9f STS direct -**0- */
  1295. INLINE void sts_di( void )
  1296. {
  1297.     CLR_NZV;
  1298.     SET_NZ16(S);
  1299.     DIRECT;
  1300.     WM16(EAD,&m6808.s);
  1301. }
  1302.  
  1303. #if macintosh
  1304. #pragma mark ____Ax____
  1305. #endif
  1306.  
  1307.  
  1308. /* $a0 SUBA indexed ?**** */
  1309. INLINE void suba_ix( void )
  1310. {
  1311.     UINT16      t,r;
  1312.     IDXBYTE(t); r = A-t;
  1313.     CLR_NZVC; SET_FLAGS8(A,t,r);
  1314.     A = r;
  1315. }
  1316.  
  1317. /* $a1 CMPA indexed ?**** */
  1318. INLINE void cmpa_ix( void )
  1319. {
  1320.     UINT16      t,r;
  1321.     IDXBYTE(t); r = A-t;
  1322.     CLR_NZVC; SET_FLAGS8(A,t,r);
  1323. }
  1324.  
  1325. /* $a2 SBCA indexed ?**** */
  1326. INLINE void sbca_ix( void )
  1327. {
  1328.     UINT16      t,r;
  1329.     IDXBYTE(t); r = A-t-(CC&0x01);
  1330.     CLR_NZVC; SET_FLAGS8(A,t,r);
  1331.     A = r;
  1332. }
  1333.  
  1334. /* $a3 SUBD indexed -**** */
  1335. INLINE void subd_ix( void )
  1336. {
  1337.     UINT32 r,d;
  1338.     PAIR b;
  1339.     IDXWORD(b);
  1340.     d = D;
  1341.     r = d - b.d;
  1342.     CLR_NZVC;
  1343.     SET_FLAGS16(d,b.d,r);
  1344.     D = r;
  1345. }
  1346.  
  1347. /* $a4 ANDA indexed -**0- */
  1348. INLINE void anda_ix( void )
  1349. {
  1350.     UINT8 t;
  1351.     IDXBYTE(t); A &= t;
  1352.     CLR_NZV; SET_NZ8(A);
  1353. }
  1354.  
  1355. /* $a5 BITA indexed -**0- */
  1356. INLINE void bita_ix( void )
  1357. {
  1358.     UINT8 t,r;
  1359.     IDXBYTE(t); r = A&t;
  1360.     CLR_NZV; SET_NZ8(r);
  1361. }
  1362.  
  1363. /* $a6 LDA indexed -**0- */
  1364. INLINE void lda_ix( void )
  1365. {
  1366.     IDXBYTE(A);
  1367.     CLR_NZV; SET_NZ8(A);
  1368. }
  1369.  
  1370. /* $a7 STA indexed -**0- */
  1371. INLINE void sta_ix( void )
  1372. {
  1373.     CLR_NZV; SET_NZ8(A);
  1374.     INDEXED; WM(EAD,A);
  1375. }
  1376.  
  1377. /* $a8 EORA indexed -**0- */
  1378. INLINE void eora_ix( void )
  1379. {
  1380.     UINT8 t;
  1381.     IDXBYTE(t); A ^= t;
  1382.     CLR_NZV; SET_NZ8(A);
  1383. }
  1384.  
  1385. /* $a9 ADCA indexed ***** */
  1386. INLINE void adca_ix( void )
  1387. {
  1388.     UINT16 t,r;
  1389.     IDXBYTE(t); r = A+t+(CC&0x01);
  1390.     CLR_HNZVC; SET_FLAGS8(A,t,r); SET_H(A,t,r);
  1391.     A = r;
  1392. }
  1393.  
  1394. /* $aa ORA indexed -**0- */
  1395. INLINE void ora_ix( void )
  1396. {
  1397.     UINT8 t;
  1398.     IDXBYTE(t); A |= t;
  1399.     CLR_NZV; SET_NZ8(A);
  1400. }
  1401.  
  1402. /* $ab ADDA indexed ***** */
  1403. INLINE void adda_ix( void )
  1404. {
  1405.     UINT16 t,r;
  1406.     IDXBYTE(t); r = A+t;
  1407.     CLR_HNZVC; SET_FLAGS8(A,t,r); SET_H(A,t,r);
  1408.     A = r;
  1409. }
  1410.  
  1411. /* $ac CMPX indexed -***- */
  1412. INLINE void cmpx_ix( void )
  1413. {
  1414.     UINT32 r,d;
  1415.     PAIR b;
  1416.     IDXWORD(b);
  1417.     d = X;
  1418.     r = d - b.d;
  1419.     CLR_NZV;
  1420.     SET_NZ16(r); SET_V16(d,b.d,r);
  1421. }
  1422.  
  1423. /* $ac CPX indexed -**** (6803)*/
  1424. INLINE void cpx_ix( void )
  1425. {
  1426.     UINT32 r,d;
  1427.     PAIR b;
  1428.     IDXWORD(b);
  1429.     d = X;
  1430.     r = d - b.d;
  1431.     CLR_NZVC; SET_FLAGS16(d,b.d,r);
  1432. }
  1433.  
  1434. /* $ad JSR indexed ----- */
  1435. INLINE void jsr_ix( void )
  1436. {
  1437.     INDEXED;
  1438.     PUSHWORD(pPC);
  1439.     PC = EA;
  1440.     CHANGE_PC();
  1441. }
  1442.  
  1443. /* $ae LDS indexed -**0- */
  1444. INLINE void lds_ix( void )
  1445. {
  1446.     IDXWORD(m6808.s);
  1447.     CLR_NZV;
  1448.     SET_NZ16(S);
  1449. }
  1450.  
  1451. /* $af STS indexed -**0- */
  1452. INLINE void sts_ix( void )
  1453. {
  1454.     CLR_NZV;
  1455.     SET_NZ16(S);
  1456.     INDEXED;
  1457.     WM16(EAD,&m6808.s);
  1458. }
  1459.  
  1460. #if macintosh
  1461. #pragma mark ____Bx____
  1462. #endif
  1463.  
  1464. /* $b0 SUBA extended ?**** */
  1465. INLINE void suba_ex( void )
  1466. {
  1467.     UINT16      t,r;
  1468.     EXTBYTE(t); r = A-t;
  1469.     CLR_NZVC; SET_FLAGS8(A,t,r);
  1470.     A = r;
  1471. }
  1472.  
  1473. /* $b1 CMPA extended ?**** */
  1474. INLINE void cmpa_ex( void )
  1475. {
  1476.     UINT16      t,r;
  1477.     EXTBYTE(t); r = A-t;
  1478.     CLR_NZVC; SET_FLAGS8(A,t,r);
  1479. }
  1480.  
  1481. /* $b2 SBCA extended ?**** */
  1482. INLINE void sbca_ex( void )
  1483. {
  1484.     UINT16      t,r;
  1485.     EXTBYTE(t); r = A-t-(CC&0x01);
  1486.     CLR_NZVC; SET_FLAGS8(A,t,r);
  1487.     A = r;
  1488. }
  1489.  
  1490. /* $b3 SUBD extended -**** */
  1491. INLINE void subd_ex( void )
  1492. {
  1493.     UINT32 r,d;
  1494.     PAIR b;
  1495.     EXTWORD(b);
  1496.     d = D;
  1497.     r = d - b.d;
  1498.     CLR_NZVC;
  1499.     SET_FLAGS16(d,b.d,r);
  1500.     D=r;
  1501. }
  1502.  
  1503. /* $b4 ANDA extended -**0- */
  1504. INLINE void anda_ex( void )
  1505. {
  1506.     UINT8 t;
  1507.     EXTBYTE(t); A &= t;
  1508.     CLR_NZV; SET_NZ8(A);
  1509. }
  1510.  
  1511. /* $b5 BITA extended -**0- */
  1512. INLINE void bita_ex( void )
  1513. {
  1514.     UINT8 t,r;
  1515.     EXTBYTE(t); r = A&t;
  1516.     CLR_NZV; SET_NZ8(r);
  1517. }
  1518.  
  1519. /* $b6 LDA extended -**0- */
  1520. INLINE void lda_ex( void )
  1521. {
  1522.     EXTBYTE(A);
  1523.     CLR_NZV; SET_NZ8(A);
  1524. }
  1525.  
  1526. /* $b7 STA extended -**0- */
  1527. INLINE void sta_ex( void )
  1528. {
  1529.     CLR_NZV; SET_NZ8(A);
  1530.     EXTENDED; WM(EAD,A);
  1531. }
  1532.  
  1533. /* $b8 EORA extended -**0- */
  1534. INLINE void eora_ex( void )
  1535. {
  1536.     UINT8 t;
  1537.     EXTBYTE(t); A ^= t;
  1538.     CLR_NZV; SET_NZ8(A);
  1539. }
  1540.  
  1541. /* $b9 ADCA extended ***** */
  1542. INLINE void adca_ex( void )
  1543. {
  1544.     UINT16 t,r;
  1545.     EXTBYTE(t); r = A+t+(CC&0x01);
  1546.     CLR_HNZVC; SET_FLAGS8(A,t,r); SET_H(A,t,r);
  1547.     A = r;
  1548. }
  1549.  
  1550. /* $ba ORA extended -**0- */
  1551. INLINE void ora_ex( void )
  1552. {
  1553.     UINT8 t;
  1554.     EXTBYTE(t); A |= t;
  1555.     CLR_NZV; SET_NZ8(A);
  1556. }
  1557.  
  1558. /* $bb ADDA extended ***** */
  1559. INLINE void adda_ex( void )
  1560. {
  1561.     UINT16 t,r;
  1562.     EXTBYTE(t); r = A+t;
  1563.     CLR_HNZVC; SET_FLAGS8(A,t,r); SET_H(A,t,r);
  1564.     A = r;
  1565. }
  1566.  
  1567. /* $bc CMPX extended -***- */
  1568. INLINE void cmpx_ex( void )
  1569. {
  1570.     UINT32 r,d;
  1571.     PAIR b;
  1572.     EXTWORD(b);
  1573.     d = X;
  1574.     r = d - b.d;
  1575.     CLR_NZV;
  1576.     SET_NZ16(r); SET_V16(d,b.d,r);
  1577. }
  1578.  
  1579. /* $bc CPX extended -**** (6803) */
  1580. INLINE void cpx_ex( void )
  1581. {
  1582.     UINT32 r,d;
  1583.     PAIR b;
  1584.     EXTWORD(b);
  1585.     d = X;
  1586.     r = d - b.d;
  1587.     CLR_NZVC; SET_FLAGS16(d,b.d,r);
  1588. }
  1589.  
  1590. /* $bd JSR extended ----- */
  1591. INLINE void jsr_ex( void )
  1592. {
  1593.     EXTENDED;
  1594.     PUSHWORD(pPC);
  1595.     PC = EA;
  1596.     CHANGE_PC();
  1597. }
  1598.  
  1599. /* $be LDS extended -**0- */
  1600. INLINE void lds_ex( void )
  1601. {
  1602.     EXTWORD(m6808.s);
  1603.     CLR_NZV;
  1604.     SET_NZ16(S);
  1605. }
  1606.  
  1607. /* $bf STS extended -**0- */
  1608. INLINE void sts_ex( void )
  1609. {
  1610.     CLR_NZV;
  1611.     SET_NZ16(S);
  1612.     EXTENDED;
  1613.     WM16(EAD,&m6808.s);
  1614. }
  1615.  
  1616.  
  1617. #if macintosh
  1618. #pragma mark ____Cx____
  1619. #endif
  1620.  
  1621. /* $c0 SUBB immediate ?**** */
  1622. INLINE void subb_im( void )
  1623. {
  1624.     UINT16      t,r;
  1625.     IMMBYTE(t); r = B-t;
  1626.     CLR_NZVC; SET_FLAGS8(B,t,r);
  1627.     B = r;
  1628. }
  1629.  
  1630. /* $c1 CMPB immediate ?**** */
  1631. INLINE void cmpb_im( void )
  1632. {
  1633.     UINT16      t,r;
  1634.     IMMBYTE(t); r = B-t;
  1635.     CLR_NZVC; SET_FLAGS8(B,t,r);
  1636. }
  1637.  
  1638. /* $c2 SBCB immediate ?**** */
  1639. INLINE void sbcb_im( void )
  1640. {
  1641.     UINT16      t,r;
  1642.     IMMBYTE(t); r = B-t-(CC&0x01);
  1643.     CLR_NZVC; SET_FLAGS8(B,t,r);
  1644.     B = r;
  1645. }
  1646.  
  1647. /* $c3 ADDD immediate -**** */
  1648. INLINE void addd_im( void )
  1649. {
  1650.     UINT32 r,d;
  1651.     PAIR b;
  1652.     IMMWORD(b);
  1653.     d = D;
  1654.     r = d + b.d;
  1655.     CLR_NZVC;
  1656.     SET_FLAGS16(d,b.d,r);
  1657.     D = r;
  1658. }
  1659.  
  1660. /* $c4 ANDB immediate -**0- */
  1661. INLINE void andb_im( void )
  1662. {
  1663.     UINT8 t;
  1664.     IMMBYTE(t); B &= t;
  1665.     CLR_NZV; SET_NZ8(B);
  1666. }
  1667.  
  1668. /* $c5 BITB immediate -**0- */
  1669. INLINE void bitb_im( void )
  1670. {
  1671.     UINT8 t,r;
  1672.     IMMBYTE(t); r = B&t;
  1673.     CLR_NZV; SET_NZ8(r);
  1674. }
  1675.  
  1676. /* $c6 LDB immediate -**0- */
  1677. INLINE void ldb_im( void )
  1678. {
  1679.     IMMBYTE(B);
  1680.     CLR_NZV; SET_NZ8(B);
  1681. }
  1682.  
  1683. /* is this a legal instruction? */
  1684. /* $c7 STB immediate -**0- */
  1685. INLINE void stb_im( void )
  1686. {
  1687.     CLR_NZV; SET_NZ8(B);
  1688.     IMM8; WM(EAD,B);
  1689. }
  1690.  
  1691. /* $c8 EORB immediate -**0- */
  1692. INLINE void eorb_im( void )
  1693. {
  1694.     UINT8 t;
  1695.     IMMBYTE(t); B ^= t;
  1696.     CLR_NZV; SET_NZ8(B);
  1697. }
  1698.  
  1699. /* $c9 ADCB immediate ***** */
  1700. INLINE void adcb_im( void )
  1701. {
  1702.     UINT16 t,r;
  1703.     IMMBYTE(t); r = B+t+(CC&0x01);
  1704.     CLR_HNZVC; SET_FLAGS8(B,t,r); SET_H(B,t,r);
  1705.     B = r;
  1706. }
  1707.  
  1708. /* $ca ORB immediate -**0- */
  1709. INLINE void orb_im( void )
  1710. {
  1711.     UINT8 t;
  1712.     IMMBYTE(t); B |= t;
  1713.     CLR_NZV; SET_NZ8(B);
  1714. }
  1715.  
  1716. /* $cb ADDB immediate ***** */
  1717. INLINE void addb_im( void )
  1718. {
  1719.     UINT16 t,r;
  1720.     IMMBYTE(t); r = B+t;
  1721.     CLR_HNZVC; SET_FLAGS8(B,t,r); SET_H(B,t,r);
  1722.     B = r;
  1723. }
  1724.  
  1725. /* $CC LDD immediate -**0- */
  1726. INLINE void ldd_im( void )
  1727. {
  1728.     IMMWORD(m6808.d);
  1729.     CLR_NZV;
  1730.     SET_NZ16(D);
  1731. }
  1732.  
  1733. /* is this a legal instruction? */
  1734. /* $cd STD immediate -**0- */
  1735. INLINE void std_im( void )
  1736. {
  1737.     IMM16;
  1738.     CLR_NZV;
  1739.     SET_NZ16(D);
  1740.     WM16(EAD,&m6808.d);
  1741. }
  1742.  
  1743. /* $ce LDX immediate -**0- */
  1744. INLINE void ldx_im( void )
  1745. {
  1746.     IMMWORD(m6808.x);
  1747.     CLR_NZV;
  1748.     SET_NZ16(X);
  1749. }
  1750.  
  1751. /* $cf STX immediate -**0- */
  1752. INLINE void stx_im( void )
  1753. {
  1754.     CLR_NZV;
  1755.     SET_NZ16(X);
  1756.     IMM16;
  1757.     WM16(EAD,&m6808.x);
  1758. }
  1759.  
  1760.  
  1761. #if macintosh
  1762. #pragma mark ____Dx____
  1763. #endif
  1764.  
  1765. /* $d0 SUBB direct ?**** */
  1766. INLINE void subb_di( void )
  1767. {
  1768.     UINT16      t,r;
  1769.     DIRBYTE(t); r = B-t;
  1770.     CLR_NZVC; SET_FLAGS8(B,t,r);
  1771.     B = r;
  1772. }
  1773.  
  1774. /* $d1 CMPB direct ?**** */
  1775. INLINE void cmpb_di( void )
  1776. {
  1777.     UINT16      t,r;
  1778.     DIRBYTE(t); r = B-t;
  1779.     CLR_NZVC; SET_FLAGS8(B,t,r);
  1780. }
  1781.  
  1782. /* $d2 SBCB direct ?**** */
  1783. INLINE void sbcb_di( void )
  1784. {
  1785.     UINT16      t,r;
  1786.     DIRBYTE(t); r = B-t-(CC&0x01);
  1787.     CLR_NZVC; SET_FLAGS8(B,t,r);
  1788.     B = r;
  1789. }
  1790.  
  1791. /* $d3 ADDD direct -**** */
  1792. INLINE void addd_di( void )
  1793. {
  1794.     UINT32 r,d;
  1795.     PAIR b;
  1796.     DIRWORD(b);
  1797.     d = D;
  1798.     r = d + b.d;
  1799.     CLR_NZVC;
  1800.     SET_FLAGS16(d,b.d,r);
  1801.     D = r;
  1802. }
  1803.  
  1804. /* $d4 ANDB direct -**0- */
  1805. INLINE void andb_di( void )
  1806. {
  1807.     UINT8 t;
  1808.     DIRBYTE(t); B &= t;
  1809.     CLR_NZV; SET_NZ8(B);
  1810. }
  1811.  
  1812. /* $d5 BITB direct -**0- */
  1813. INLINE void bitb_di( void )
  1814. {
  1815.     UINT8 t,r;
  1816.     DIRBYTE(t); r = B&t;
  1817.     CLR_NZV; SET_NZ8(r);
  1818. }
  1819.  
  1820. /* $d6 LDB direct -**0- */
  1821. INLINE void ldb_di( void )
  1822. {
  1823.     DIRBYTE(B);
  1824.     CLR_NZV; SET_NZ8(B);
  1825. }
  1826.  
  1827. /* $d7 STB direct -**0- */
  1828. INLINE void stb_di( void )
  1829. {
  1830.     CLR_NZV; SET_NZ8(B);
  1831.     DIRECT; WM(EAD,B);
  1832. }
  1833.  
  1834. /* $d8 EORB direct -**0- */
  1835. INLINE void eorb_di( void )
  1836. {
  1837.     UINT8 t;
  1838.     DIRBYTE(t); B ^= t;
  1839.     CLR_NZV; SET_NZ8(B);
  1840. }
  1841.  
  1842. /* $d9 ADCB direct ***** */
  1843. INLINE void adcb_di( void )
  1844. {
  1845.     UINT16 t,r;
  1846.     DIRBYTE(t); r = B+t+(CC&0x01);
  1847.     CLR_HNZVC; SET_FLAGS8(B,t,r); SET_H(B,t,r);
  1848.     B = r;
  1849. }
  1850.  
  1851. /* $da ORB direct -**0- */
  1852. INLINE void orb_di( void )
  1853. {
  1854.     UINT8 t;
  1855.     DIRBYTE(t); B |= t;
  1856.     CLR_NZV; SET_NZ8(B);
  1857. }
  1858.  
  1859. /* $db ADDB direct ***** */
  1860. INLINE void addb_di( void )
  1861. {
  1862.     UINT16 t,r;
  1863.     DIRBYTE(t); r = B+t;
  1864.     CLR_HNZVC; SET_FLAGS8(B,t,r); SET_H(B,t,r);
  1865.     B = r;
  1866. }
  1867.  
  1868. /* $dc LDD direct -**0- */
  1869. INLINE void ldd_di( void )
  1870. {
  1871.     DIRWORD(m6808.d);
  1872.     CLR_NZV;
  1873.     SET_NZ16(D);
  1874. }
  1875.  
  1876. /* $dd STD direct -**0- */
  1877. INLINE void std_di( void )
  1878. {
  1879.     DIRECT;
  1880.     CLR_NZV;
  1881.     SET_NZ16(D);
  1882.     WM16(EAD,&m6808.d);
  1883. }
  1884.  
  1885. /* $de LDX direct -**0- */
  1886. INLINE void ldx_di( void )
  1887. {
  1888.     DIRWORD(m6808.x);
  1889.     CLR_NZV;
  1890.     SET_NZ16(X);
  1891. }
  1892.  
  1893. /* $dF STX direct -**0- */
  1894. INLINE void stx_di( void )
  1895. {
  1896.     CLR_NZV;
  1897.     SET_NZ16(X);
  1898.     DIRECT;
  1899.     WM16(EAD,&m6808.x);
  1900. }
  1901.  
  1902. #if macintosh
  1903. #pragma mark ____Ex____
  1904. #endif
  1905.  
  1906.  
  1907. /* $e0 SUBB indexed ?**** */
  1908. INLINE void subb_ix( void )
  1909. {
  1910.     UINT16      t,r;
  1911.     IDXBYTE(t); r = B-t;
  1912.     CLR_NZVC; SET_FLAGS8(B,t,r);
  1913.     B = r;
  1914. }
  1915.  
  1916. /* $e1 CMPB indexed ?**** */
  1917. INLINE void cmpb_ix( void )
  1918. {
  1919.     UINT16      t,r;
  1920.     IDXBYTE(t); r = B-t;
  1921.     CLR_NZVC; SET_FLAGS8(B,t,r);
  1922. }
  1923.  
  1924. /* $e2 SBCB indexed ?**** */
  1925. INLINE void sbcb_ix( void )
  1926. {
  1927.     UINT16      t,r;
  1928.     IDXBYTE(t); r = B-t-(CC&0x01);
  1929.     CLR_NZVC; SET_FLAGS8(B,t,r);
  1930.     B = r;
  1931. }
  1932.  
  1933. /* $e3 ADDD indexed -**** */
  1934. INLINE void addd_ix( void )
  1935. {
  1936.     UINT32 r,d;
  1937.     PAIR b;
  1938.     IDXWORD(b);
  1939.     d = D;
  1940.     r = d + b.d;
  1941.     CLR_NZVC;
  1942.     SET_FLAGS16(d,b.d,r);
  1943.     D = r;
  1944. }
  1945.  
  1946. /* $e4 ANDB indexed -**0- */
  1947. INLINE void andb_ix( void )
  1948. {
  1949.     UINT8 t;
  1950.     IDXBYTE(t); B &= t;
  1951.     CLR_NZV; SET_NZ8(B);
  1952. }
  1953.  
  1954. /* $e5 BITB indexed -**0- */
  1955. INLINE void bitb_ix( void )
  1956. {
  1957.     UINT8 t,r;
  1958.     IDXBYTE(t); r = B&t;
  1959.     CLR_NZV; SET_NZ8(r);
  1960. }
  1961.  
  1962. /* $e6 LDB indexed -**0- */
  1963. INLINE void ldb_ix( void )
  1964. {
  1965.     IDXBYTE(B);
  1966.     CLR_NZV; SET_NZ8(B);
  1967. }
  1968.  
  1969. /* $e7 STB indexed -**0- */
  1970. INLINE void stb_ix( void )
  1971. {
  1972.     CLR_NZV; SET_NZ8(B);
  1973.     INDEXED; WM(EAD,B);
  1974. }
  1975.  
  1976. /* $e8 EORB indexed -**0- */
  1977. INLINE void eorb_ix( void )
  1978. {
  1979.     UINT8 t;
  1980.     IDXBYTE(t); B ^= t;
  1981.     CLR_NZV; SET_NZ8(B);
  1982. }
  1983.  
  1984. /* $e9 ADCB indexed ***** */
  1985. INLINE void adcb_ix( void )
  1986. {
  1987.     UINT16 t,r;
  1988.     IDXBYTE(t); r = B+t+(CC&0x01);
  1989.     CLR_HNZVC; SET_FLAGS8(B,t,r); SET_H(B,t,r);
  1990.     B = r;
  1991. }
  1992.  
  1993. /* $ea ORB indexed -**0- */
  1994. INLINE void orb_ix( void )
  1995. {
  1996.     UINT8 t;
  1997.     IDXBYTE(t); B |= t;
  1998.     CLR_NZV; SET_NZ8(B);
  1999. }
  2000.  
  2001. /* $eb ADDB indexed ***** */
  2002. INLINE void addb_ix( void )
  2003. {
  2004.     UINT16 t,r;
  2005.     IDXBYTE(t); r = B+t;
  2006.     CLR_HNZVC; SET_FLAGS8(B,t,r); SET_H(B,t,r);
  2007.     B = r;
  2008. }
  2009.  
  2010. /* $ec LDD indexed -**0- */
  2011. INLINE void ldd_ix( void )
  2012. {
  2013.     IDXWORD(m6808.d);
  2014.     CLR_NZV;
  2015.     SET_NZ16(D);
  2016. }
  2017.  
  2018. /* $ed STD indexed -**0- */
  2019. INLINE void std_ix( void )
  2020. {
  2021.     INDEXED;
  2022.     CLR_NZV;
  2023.     SET_NZ16(D);
  2024.     WM16(EAD,&m6808.d);
  2025. }
  2026.  
  2027. /* $ee LDX indexed -**0- */
  2028. INLINE void ldx_ix( void )
  2029. {
  2030.     IDXWORD(m6808.x);
  2031.     CLR_NZV;
  2032.     SET_NZ16(X);
  2033. }
  2034.  
  2035. /* $ef STX indexed -**0- */
  2036. INLINE void stx_ix( void )
  2037. {
  2038.     CLR_NZV;
  2039.     SET_NZ16(X);
  2040.     INDEXED;
  2041.     WM16(EAD,&m6808.x);
  2042. }
  2043.  
  2044. #if macintosh
  2045. #pragma mark ____Fx____
  2046. #endif
  2047.  
  2048. /* $f0 SUBB extended ?**** */
  2049. INLINE void subb_ex( void )
  2050. {
  2051.     UINT16      t,r;
  2052.     EXTBYTE(t); r = B-t;
  2053.     CLR_NZVC; SET_FLAGS8(B,t,r);
  2054.     B = r;
  2055. }
  2056.  
  2057. /* $f1 CMPB extended ?**** */
  2058. INLINE void cmpb_ex( void )
  2059. {
  2060.     UINT16      t,r;
  2061.     EXTBYTE(t); r = B-t;
  2062.     CLR_NZVC; SET_FLAGS8(B,t,r);
  2063. }
  2064.  
  2065. /* $f2 SBCB extended ?**** */
  2066. INLINE void sbcb_ex( void )
  2067. {
  2068.     UINT16      t,r;
  2069.     EXTBYTE(t); r = B-t-(CC&0x01);
  2070.     CLR_NZVC; SET_FLAGS8(B,t,r);
  2071.     B = r;
  2072. }
  2073.  
  2074. /* $f3 ADDD extended -**** */
  2075. INLINE void addd_ex( void )
  2076. {
  2077.     UINT32 r,d;
  2078.     PAIR b;
  2079.     EXTWORD(b);
  2080.     d = D;
  2081.     r = d + b.d;
  2082.     CLR_NZVC;
  2083.     SET_FLAGS16(d,b.d,r);
  2084.     D = r;
  2085. }
  2086.  
  2087. /* $f4 ANDB extended -**0- */
  2088. INLINE void andb_ex( void )
  2089. {
  2090.     UINT8 t;
  2091.     EXTBYTE(t);
  2092.     B &= t;
  2093.     CLR_NZV;
  2094.     SET_NZ8(B);
  2095. }
  2096.  
  2097. /* $f5 BITB extended -**0- */
  2098. INLINE void bitb_ex( void )
  2099. {
  2100.     UINT8 t,r;
  2101.     EXTBYTE(t);
  2102.     r = B & t;
  2103.     CLR_NZV;
  2104.     SET_NZ8(r);
  2105. }
  2106.  
  2107. /* $f6 LDB extended -**0- */
  2108. INLINE void ldb_ex( void )
  2109. {
  2110.     EXTBYTE(B);
  2111.     CLR_NZV;
  2112.     SET_NZ8(B);
  2113. }
  2114.  
  2115. /* $f7 STB extended -**0- */
  2116. INLINE void stb_ex( void )
  2117. {
  2118.     CLR_NZV; SET_NZ8(B);
  2119.     EXTENDED; WM(EAD,B);
  2120. }
  2121.  
  2122. /* $f8 EORB extended -**0- */
  2123. INLINE void eorb_ex( void )
  2124. {
  2125.     UINT8 t;
  2126.     EXTBYTE(t); B ^= t;
  2127.     CLR_NZV; SET_NZ8(B);
  2128. }
  2129.  
  2130. /* $f9 ADCB extended ***** */
  2131. INLINE void adcb_ex( void )
  2132. {
  2133.     UINT16 t,r;
  2134.     EXTBYTE(t); r = B+t+(CC&0x01);
  2135.     CLR_HNZVC; SET_FLAGS8(B,t,r); SET_H(B,t,r);
  2136.     B = r;
  2137. }
  2138.  
  2139. /* $fa ORB extended -**0- */
  2140. INLINE void orb_ex( void )
  2141. {
  2142.     UINT8 t;
  2143.     EXTBYTE(t); B |= t;
  2144.     CLR_NZV; SET_NZ8(B);
  2145. }
  2146.  
  2147. /* $fb ADDB extended ***** */
  2148. INLINE void addb_ex( void )
  2149. {
  2150.     UINT16 t,r;
  2151.     EXTBYTE(t); r = B+t;
  2152.     CLR_HNZVC; SET_FLAGS8(B,t,r); SET_H(B,t,r);
  2153.     B = r;
  2154. }
  2155.  
  2156. /* $fc LDD extended -**0- */
  2157. INLINE void ldd_ex( void )
  2158. {
  2159.     EXTWORD(m6808.d);
  2160.     CLR_NZV;
  2161.     SET_NZ16(D);
  2162. }
  2163.  
  2164. /* $fc ADDX extended -****    NSC8105 only.  Flags are a guess */
  2165. INLINE void addx_ex( void )
  2166. {
  2167.     UINT32 r,d;
  2168.     PAIR b;
  2169.     EXTWORD(b);
  2170.     d = X;
  2171.     r = d + b.d;
  2172.     CLR_NZVC;
  2173.     SET_FLAGS16(d,b.d,r);
  2174.     X = r;
  2175. }
  2176.  
  2177. /* $fd STD extended -**0- */
  2178. INLINE void std_ex( void )
  2179. {
  2180.     EXTENDED;
  2181.     CLR_NZV;
  2182.     SET_NZ16(D);
  2183.     WM16(EAD,&m6808.d);
  2184. }
  2185.  
  2186. /* $fe LDX extended -**0- */
  2187. INLINE void ldx_ex( void )
  2188. {
  2189.     EXTWORD(m6808.x);
  2190.     CLR_NZV;
  2191.     SET_NZ16(X);
  2192. }
  2193.  
  2194. /* $ff STX extended -**0- */
  2195. INLINE void stx_ex( void )
  2196. {
  2197.     CLR_NZV;
  2198.     SET_NZ16(X);
  2199.     EXTENDED;
  2200.     WM16(EAD,&m6808.x);
  2201. }
  2202.